package com.dragon.modules.yuegou.query.coupon;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dragon.modules.yuegou.entity.coupon.ParkApplyEntity;
import com.dragon.modules.yuegou.enums.coupon.ParkApplyStatus;
import com.dragon.modules.yuegou.enums.coupon.ParkApplyType;
import com.dragon.modules.yuegou.mybatis.Condition;
import com.dragon.modules.yuegou.mybatis.Query;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonUnwrapped;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 停车券券申请表 动态查询条件
 *
 * @author pbuilder generated
 * @date 2021-05-11 17:09:45
 * @version 2.0
 */
@JsonInclude(Include.NON_NULL)
public class ParkApplyQuery extends ParkApplyEntity implements Query<ParkApplyEntity> {

	/** 查询条件 */
	@JsonUnwrapped(prefix = "id")
	private Condition<String> idCondition;

	/** [枚举]券类型：0-停车券-PARK、1-优惠券-DISCOUNT查询条件 */
	@JsonUnwrapped(prefix = "type")
	private Condition<ParkApplyType> typeCondition;

	/** 订单号查询条件 */
	@JsonUnwrapped(prefix = "orderNo")
	private Condition<String> orderNoCondition;

	/** 商圈ID查询条件 */
	@JsonUnwrapped(prefix = "busdId")
	private Condition<String> busdIdCondition;

	/** 商户ID查询条件 */
	@JsonUnwrapped(prefix = "merchantId")
	private Condition<String> merchantIdCondition;

	/** 申请购买数量查询条件 */
	@JsonUnwrapped(prefix = "buyNum")
	private Condition<Integer> buyNumCondition;

	/** 审核确认数量查询条件 */
	@JsonUnwrapped(prefix = "checkNum")
	private Condition<Integer> checkNumCondition;

	/** 有效起始时间查询条件 */
	@JsonUnwrapped(prefix = "beginTime")
	private Condition<LocalDateTime> beginTimeCondition;

	/** 有效结束时间查询条件 */
	@JsonUnwrapped(prefix = "endTime")
	private Condition<LocalDateTime> endTimeCondition;

	/** 申请人查询条件 */
	@JsonUnwrapped(prefix = "applyBy")
	private Condition<String> applyByCondition;

	/** 申请时间查询条件 */
	@JsonUnwrapped(prefix = "applyTime")
	private Condition<LocalDateTime> applyTimeCondition;

	/** 审核人查询条件 */
	@JsonUnwrapped(prefix = "checkBy")
	private Condition<String> checkByCondition;

	/** 审核时间查询条件 */
	@JsonUnwrapped(prefix = "checkTime")
	private Condition<LocalDateTime> checkTimeCondition;

	/** 审核反馈查询条件 */
	@JsonUnwrapped(prefix = "checkRs")
	private Condition<String> checkRsCondition;

	/** [枚举]状态：0-待提交-READY、1-待审核-UNCHECK、2-审核通过-PASS、3-审核未通过-UNPASS、4-已支付-PAYED、5-已失效-INVALID、6-预支付-PREPAID查询条件 */
	@JsonUnwrapped(prefix = "status")
	private Condition<ParkApplyStatus> statusCondition;

	/** 审核有效起始时间查询条件 */
	@JsonUnwrapped(prefix = "checkBeginTime")
	private Condition<LocalDateTime> checkBeginTimeCondition;

	/** 审核有效结束时间查询条件 */
	@JsonUnwrapped(prefix = "checkEndTime")
	private Condition<LocalDateTime> checkEndTimeCondition;

	/** 已使用数量查询条件 */
	@JsonUnwrapped(prefix = "useNum")
	private Condition<Integer> useNumCondition;

	/** 作废数量查询条件 */
	@JsonUnwrapped(prefix = "invalidNum")
	private Condition<Integer> invalidNumCondition;

	/** skuId查询条件 */
	@JsonUnwrapped(prefix = "skuId")
	private Condition<String> skuIdCondition;

	/** 审核金额查询条件 */
	@JsonUnwrapped(prefix = "checkPrice")
	private Condition<BigDecimal> checkPriceCondition;

	/** 支付现金查询条件 */
	@JsonUnwrapped(prefix = "payCash")
	private Condition<BigDecimal> payCashCondition;

	/** 备注信息查询条件 */
	@JsonUnwrapped(prefix = "remarks")
	private Condition<String> remarksCondition;

	/**
	 * 构造一个查询条件对象
	 */
	public ParkApplyQuery() {
		super();
	}

	/**
	 * 依据实体对象构造一个查询条件对象
	 *
	 * @param entity 实体对象
	 */
	public ParkApplyQuery(ParkApplyEntity entity) {
		super(entity);
	}

	/**
	 * 依据其它查询条件对象的信息构造一个查询条件对象
	 *
	 * @param other 查询条件对象
	 */
	public ParkApplyQuery(ParkApplyQuery other) {
		super(other);
		if(other.idCondition != null) {
			this.idCondition = other.idCondition.copy();
		}
		if(other.typeCondition != null) {
			this.typeCondition = other.typeCondition.copy();
		}
		if(other.orderNoCondition != null) {
			this.orderNoCondition = other.orderNoCondition.copy();
		}
		if(other.busdIdCondition != null) {
			this.busdIdCondition = other.busdIdCondition.copy();
		}
		if(other.merchantIdCondition != null) {
			this.merchantIdCondition = other.merchantIdCondition.copy();
		}
		if(other.buyNumCondition != null) {
			this.buyNumCondition = other.buyNumCondition.copy();
		}
		if(other.checkNumCondition != null) {
			this.checkNumCondition = other.checkNumCondition.copy();
		}
		if(other.beginTimeCondition != null) {
			this.beginTimeCondition = other.beginTimeCondition.copy();
		}
		if(other.endTimeCondition != null) {
			this.endTimeCondition = other.endTimeCondition.copy();
		}
		if(other.applyByCondition != null) {
			this.applyByCondition = other.applyByCondition.copy();
		}
		if(other.applyTimeCondition != null) {
			this.applyTimeCondition = other.applyTimeCondition.copy();
		}
		if(other.checkByCondition != null) {
			this.checkByCondition = other.checkByCondition.copy();
		}
		if(other.checkTimeCondition != null) {
			this.checkTimeCondition = other.checkTimeCondition.copy();
		}
		if(other.checkRsCondition != null) {
			this.checkRsCondition = other.checkRsCondition.copy();
		}
		this.setOther(other);
	}
	private void setOther(ParkApplyQuery other){
		if(other.statusCondition != null) {
			this.statusCondition = other.statusCondition.copy();
		}
		if(other.checkBeginTimeCondition != null) {
			this.checkBeginTimeCondition = other.checkBeginTimeCondition.copy();
		}
		if(other.checkEndTimeCondition != null) {
			this.checkEndTimeCondition = other.checkEndTimeCondition.copy();
		}
		if(other.useNumCondition != null) {
			this.useNumCondition = other.useNumCondition.copy();
		}
		if(other.invalidNumCondition != null) {
			this.invalidNumCondition = other.invalidNumCondition.copy();
		}
		if(other.skuIdCondition != null) {
			this.skuIdCondition = other.skuIdCondition.copy();
		}
		if(other.checkPriceCondition != null) {
			this.checkPriceCondition = other.checkPriceCondition.copy();
		}
		if(other.payCashCondition != null) {
			this.payCashCondition = other.payCashCondition.copy();
		}
		if(other.remarksCondition != null) {
			this.remarksCondition = other.remarksCondition.copy();
		}
	}

	@Override
	public QueryWrapper<ParkApplyEntity> toQueryWrapper() {
		QueryWrapper<ParkApplyEntity> wrapper = new QueryWrapper<>(this);
		if (idCondition != null) {
			idCondition.toWrapper(wrapper, COL_ID);
		}
		if (typeCondition != null) {
			typeCondition.toWrapper(wrapper, COL_TYPE);
		}
		if (orderNoCondition != null) {
			orderNoCondition.toWrapper(wrapper, COL_ORDER_NO);
		}
		if (busdIdCondition != null) {
			busdIdCondition.toWrapper(wrapper, COL_BUSD_ID);
		}
		if (merchantIdCondition != null) {
			merchantIdCondition.toWrapper(wrapper, COL_MERCHANT_ID);
		}
		if (buyNumCondition != null) {
			buyNumCondition.toWrapper(wrapper, COL_BUY_NUM);
		}
		if (checkNumCondition != null) {
			checkNumCondition.toWrapper(wrapper, COL_CHECK_NUM);
		}
		if (beginTimeCondition != null) {
			beginTimeCondition.toWrapper(wrapper, COL_BEGIN_TIME);
		}
		if (endTimeCondition != null) {
			endTimeCondition.toWrapper(wrapper, COL_END_TIME);
		}
		if (applyByCondition != null) {
			applyByCondition.toWrapper(wrapper, COL_APPLY_BY);
		}
		if (applyTimeCondition != null) {
			applyTimeCondition.toWrapper(wrapper, COL_APPLY_TIME);
		}
		if (checkByCondition != null) {
			checkByCondition.toWrapper(wrapper, COL_CHECK_BY);
		}
		if (checkTimeCondition != null) {
			checkTimeCondition.toWrapper(wrapper, COL_CHECK_TIME);
		}
		if (checkRsCondition != null) {
			checkRsCondition.toWrapper(wrapper, COL_CHECK_RS);
		}
		return getQueryWrapper(wrapper);
	}
	private QueryWrapper<ParkApplyEntity> getQueryWrapper(QueryWrapper<ParkApplyEntity> wrapper){
		if (statusCondition != null) {
			statusCondition.toWrapper(wrapper, COL_STATUS);
		}
		if (checkBeginTimeCondition != null) {
			checkBeginTimeCondition.toWrapper(wrapper, COL_CHECK_BEGIN_TIME);
		}
		if (checkEndTimeCondition != null) {
			checkEndTimeCondition.toWrapper(wrapper, COL_CHECK_END_TIME);
		}
		if (useNumCondition != null) {
			useNumCondition.toWrapper(wrapper, COL_USE_NUM);
		}
		if (invalidNumCondition != null) {
			invalidNumCondition.toWrapper(wrapper, COL_INVALID_NUM);
		}
		if (skuIdCondition != null) {
			skuIdCondition.toWrapper(wrapper, COL_SKU_ID);
		}
		if (checkPriceCondition != null) {
			checkPriceCondition.toWrapper(wrapper, COL_CHECK_PRICE);
		}
		if (payCashCondition != null) {
			payCashCondition.toWrapper(wrapper, COL_PAY_CASH);
		}
		if (remarksCondition != null) {
			remarksCondition.toWrapper(wrapper, COL_REMARKS);
		}
		return wrapper;
	}

	/**
	 * 构造并返回查询条件
	 *
	 * @return idCondition 查询条件
	 */
	public Condition<String> id() {
		this.idCondition = new Condition<>();
		return this.idCondition;
	}

	/**
	 * 获取查询条件
	 *
	 * @return idCondition 查询条件
	 */
	public Condition<String> getIdCondition() {
		return idCondition;
	}

	/**
	 * 设置查询条件
	 *
	 * @param idCondition 查询条件
	 */
	public void setIdCondition(Condition<String> idCondition) {
		this.idCondition = idCondition;
	}

	/**
	 * 构造并返回[枚举]券类型：0-停车券-PARK、1-优惠券-DISCOUNT查询条件
	 *
	 * @return typeCondition [枚举]券类型：0-停车券-PARK、1-优惠券-DISCOUNT查询条件
	 */
	public Condition<ParkApplyType> type() {
		this.typeCondition = new Condition<>();
		return this.typeCondition;
	}

	/**
	 * 获取[枚举]券类型：0-停车券-PARK、1-优惠券-DISCOUNT查询条件
	 *
	 * @return typeCondition [枚举]券类型：0-停车券-PARK、1-优惠券-DISCOUNT查询条件
	 */
	public Condition<ParkApplyType> getTypeCondition() {
		return typeCondition;
	}

	/**
	 * 设置[枚举]券类型：0-停车券-PARK、1-优惠券-DISCOUNT查询条件
	 *
	 * @param typeCondition [枚举]券类型：0-停车券-PARK、1-优惠券-DISCOUNT查询条件
	 */
	public void setTypeCondition(Condition<ParkApplyType> typeCondition) {
		this.typeCondition = typeCondition;
	}

	/**
	 * 构造并返回订单号查询条件
	 *
	 * @return orderNoCondition 订单号查询条件
	 */
	public Condition<String> orderNo() {
		this.orderNoCondition = new Condition<>();
		return this.orderNoCondition;
	}

	/**
	 * 获取订单号查询条件
	 *
	 * @return orderNoCondition 订单号查询条件
	 */
	public Condition<String> getOrderNoCondition() {
		return orderNoCondition;
	}

	/**
	 * 设置订单号查询条件
	 *
	 * @param orderNoCondition 订单号查询条件
	 */
	public void setOrderNoCondition(Condition<String> orderNoCondition) {
		this.orderNoCondition = orderNoCondition;
	}

	/**
	 * 构造并返回商圈ID查询条件
	 *
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> busdId() {
		this.busdIdCondition = new Condition<>();
		return this.busdIdCondition;
	}

	/**
	 * 获取商圈ID查询条件
	 *
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> getBusdIdCondition() {
		return busdIdCondition;
	}

	/**
	 * 设置商圈ID查询条件
	 *
	 * @param busdIdCondition 商圈ID查询条件
	 */
	public void setBusdIdCondition(Condition<String> busdIdCondition) {
		this.busdIdCondition = busdIdCondition;
	}

	/**
	 * 构造并返回商户ID查询条件
	 *
	 * @return merchantIdCondition 商户ID查询条件
	 */
	public Condition<String> merchantId() {
		this.merchantIdCondition = new Condition<>();
		return this.merchantIdCondition;
	}

	/**
	 * 获取商户ID查询条件
	 *
	 * @return merchantIdCondition 商户ID查询条件
	 */
	public Condition<String> getMerchantIdCondition() {
		return merchantIdCondition;
	}

	/**
	 * 设置商户ID查询条件
	 *
	 * @param merchantIdCondition 商户ID查询条件
	 */
	public void setMerchantIdCondition(Condition<String> merchantIdCondition) {
		this.merchantIdCondition = merchantIdCondition;
	}

	/**
	 * 构造并返回申请购买数量查询条件
	 *
	 * @return buyNumCondition 申请购买数量查询条件
	 */
	public Condition<Integer> buyNum() {
		this.buyNumCondition = new Condition<>();
		return this.buyNumCondition;
	}

	/**
	 * 获取申请购买数量查询条件
	 *
	 * @return buyNumCondition 申请购买数量查询条件
	 */
	public Condition<Integer> getBuyNumCondition() {
		return buyNumCondition;
	}

	/**
	 * 设置申请购买数量查询条件
	 *
	 * @param buyNumCondition 申请购买数量查询条件
	 */
	public void setBuyNumCondition(Condition<Integer> buyNumCondition) {
		this.buyNumCondition = buyNumCondition;
	}

	/**
	 * 构造并返回审核确认数量查询条件
	 *
	 * @return checkNumCondition 审核确认数量查询条件
	 */
	public Condition<Integer> checkNum() {
		this.checkNumCondition = new Condition<>();
		return this.checkNumCondition;
	}

	/**
	 * 获取审核确认数量查询条件
	 *
	 * @return checkNumCondition 审核确认数量查询条件
	 */
	public Condition<Integer> getCheckNumCondition() {
		return checkNumCondition;
	}

	/**
	 * 设置审核确认数量查询条件
	 *
	 * @param checkNumCondition 审核确认数量查询条件
	 */
	public void setCheckNumCondition(Condition<Integer> checkNumCondition) {
		this.checkNumCondition = checkNumCondition;
	}

	/**
	 * 构造并返回有效起始时间查询条件
	 *
	 * @return beginTimeCondition 有效起始时间查询条件
	 */
	public Condition<LocalDateTime> beginTime() {
		this.beginTimeCondition = new Condition<>();
		return this.beginTimeCondition;
	}

	/**
	 * 获取有效起始时间查询条件
	 *
	 * @return beginTimeCondition 有效起始时间查询条件
	 */
	public Condition<LocalDateTime> getBeginTimeCondition() {
		return beginTimeCondition;
	}

	/**
	 * 设置有效起始时间查询条件
	 *
	 * @param beginTimeCondition 有效起始时间查询条件
	 */
	public void setBeginTimeCondition(Condition<LocalDateTime> beginTimeCondition) {
		this.beginTimeCondition = beginTimeCondition;
	}

	/**
	 * 构造并返回有效结束时间查询条件
	 *
	 * @return endTimeCondition 有效结束时间查询条件
	 */
	public Condition<LocalDateTime> endTime() {
		this.endTimeCondition = new Condition<>();
		return this.endTimeCondition;
	}

	/**
	 * 获取有效结束时间查询条件
	 *
	 * @return endTimeCondition 有效结束时间查询条件
	 */
	public Condition<LocalDateTime> getEndTimeCondition() {
		return endTimeCondition;
	}

	/**
	 * 设置有效结束时间查询条件
	 *
	 * @param endTimeCondition 有效结束时间查询条件
	 */
	public void setEndTimeCondition(Condition<LocalDateTime> endTimeCondition) {
		this.endTimeCondition = endTimeCondition;
	}

	/**
	 * 构造并返回申请人查询条件
	 *
	 * @return applyByCondition 申请人查询条件
	 */
	public Condition<String> applyBy() {
		this.applyByCondition = new Condition<>();
		return this.applyByCondition;
	}

	/**
	 * 获取申请人查询条件
	 *
	 * @return applyByCondition 申请人查询条件
	 */
	public Condition<String> getApplyByCondition() {
		return applyByCondition;
	}

	/**
	 * 设置申请人查询条件
	 *
	 * @param applyByCondition 申请人查询条件
	 */
	public void setApplyByCondition(Condition<String> applyByCondition) {
		this.applyByCondition = applyByCondition;
	}

	/**
	 * 构造并返回申请时间查询条件
	 *
	 * @return applyTimeCondition 申请时间查询条件
	 */
	public Condition<LocalDateTime> applyTime() {
		this.applyTimeCondition = new Condition<>();
		return this.applyTimeCondition;
	}

	/**
	 * 获取申请时间查询条件
	 *
	 * @return applyTimeCondition 申请时间查询条件
	 */
	public Condition<LocalDateTime> getApplyTimeCondition() {
		return applyTimeCondition;
	}

	/**
	 * 设置申请时间查询条件
	 *
	 * @param applyTimeCondition 申请时间查询条件
	 */
	public void setApplyTimeCondition(Condition<LocalDateTime> applyTimeCondition) {
		this.applyTimeCondition = applyTimeCondition;
	}

	/**
	 * 构造并返回审核人查询条件
	 *
	 * @return checkByCondition 审核人查询条件
	 */
	public Condition<String> checkBy() {
		this.checkByCondition = new Condition<>();
		return this.checkByCondition;
	}

	/**
	 * 获取审核人查询条件
	 *
	 * @return checkByCondition 审核人查询条件
	 */
	public Condition<String> getCheckByCondition() {
		return checkByCondition;
	}

	/**
	 * 设置审核人查询条件
	 *
	 * @param checkByCondition 审核人查询条件
	 */
	public void setCheckByCondition(Condition<String> checkByCondition) {
		this.checkByCondition = checkByCondition;
	}

	/**
	 * 构造并返回审核时间查询条件
	 *
	 * @return checkTimeCondition 审核时间查询条件
	 */
	public Condition<LocalDateTime> checkTime() {
		this.checkTimeCondition = new Condition<>();
		return this.checkTimeCondition;
	}

	/**
	 * 获取审核时间查询条件
	 *
	 * @return checkTimeCondition 审核时间查询条件
	 */
	public Condition<LocalDateTime> getCheckTimeCondition() {
		return checkTimeCondition;
	}

	/**
	 * 设置审核时间查询条件
	 *
	 * @param checkTimeCondition 审核时间查询条件
	 */
	public void setCheckTimeCondition(Condition<LocalDateTime> checkTimeCondition) {
		this.checkTimeCondition = checkTimeCondition;
	}

	/**
	 * 构造并返回审核反馈查询条件
	 *
	 * @return checkRsCondition 审核反馈查询条件
	 */
	public Condition<String> checkRs() {
		this.checkRsCondition = new Condition<>();
		return this.checkRsCondition;
	}

	/**
	 * 获取审核反馈查询条件
	 *
	 * @return checkRsCondition 审核反馈查询条件
	 */
	public Condition<String> getCheckRsCondition() {
		return checkRsCondition;
	}

	/**
	 * 设置审核反馈查询条件
	 *
	 * @param checkRsCondition 审核反馈查询条件
	 */
	public void setCheckRsCondition(Condition<String> checkRsCondition) {
		this.checkRsCondition = checkRsCondition;
	}

	/**
	 * 构造并返回[枚举]状态：0-待提交-READY、1-待审核-UNCHECK、2-审核通过-PASS、3-审核未通过-UNPASS、4-已支付-PAYED、5-已失效-INVALID、6-预支付-PREPAID查询条件
	 *
	 * @return statusCondition [枚举]状态：0-待提交-READY、1-待审核-UNCHECK、2-审核通过-PASS、3-审核未通过-UNPASS、4-已支付-PAYED、5-已失效-INVALID、6-预支付-PREPAID查询条件
	 */
	public Condition<ParkApplyStatus> status() {
		this.statusCondition = new Condition<>();
		return this.statusCondition;
	}

	/**
	 * 获取[枚举]状态：0-待提交-READY、1-待审核-UNCHECK、2-审核通过-PASS、3-审核未通过-UNPASS、4-已支付-PAYED、5-已失效-INVALID、6-预支付-PREPAID查询条件
	 *
	 * @return statusCondition [枚举]状态：0-待提交-READY、1-待审核-UNCHECK、2-审核通过-PASS、3-审核未通过-UNPASS、4-已支付-PAYED、5-已失效-INVALID、6-预支付-PREPAID查询条件
	 */
	public Condition<ParkApplyStatus> getStatusCondition() {
		return statusCondition;
	}

	/**
	 * 设置[枚举]状态：0-待提交-READY、1-待审核-UNCHECK、2-审核通过-PASS、3-审核未通过-UNPASS、4-已支付-PAYED、5-已失效-INVALID、6-预支付-PREPAID查询条件
	 *
	 * @param statusCondition [枚举]状态：0-待提交-READY、1-待审核-UNCHECK、2-审核通过-PASS、3-审核未通过-UNPASS、4-已支付-PAYED、5-已失效-INVALID、6-预支付-PREPAID查询条件
	 */
	public void setStatusCondition(Condition<ParkApplyStatus> statusCondition) {
		this.statusCondition = statusCondition;
	}

	/**
	 * 构造并返回审核有效起始时间查询条件
	 *
	 * @return checkBeginTimeCondition 审核有效起始时间查询条件
	 */
	public Condition<LocalDateTime> checkBeginTime() {
		this.checkBeginTimeCondition = new Condition<>();
		return this.checkBeginTimeCondition;
	}

	/**
	 * 获取审核有效起始时间查询条件
	 *
	 * @return checkBeginTimeCondition 审核有效起始时间查询条件
	 */
	public Condition<LocalDateTime> getCheckBeginTimeCondition() {
		return checkBeginTimeCondition;
	}

	/**
	 * 设置审核有效起始时间查询条件
	 *
	 * @param checkBeginTimeCondition 审核有效起始时间查询条件
	 */
	public void setCheckBeginTimeCondition(Condition<LocalDateTime> checkBeginTimeCondition) {
		this.checkBeginTimeCondition = checkBeginTimeCondition;
	}

	/**
	 * 构造并返回审核有效结束时间查询条件
	 *
	 * @return checkEndTimeCondition 审核有效结束时间查询条件
	 */
	public Condition<LocalDateTime> checkEndTime() {
		this.checkEndTimeCondition = new Condition<>();
		return this.checkEndTimeCondition;
	}

	/**
	 * 获取审核有效结束时间查询条件
	 *
	 * @return checkEndTimeCondition 审核有效结束时间查询条件
	 */
	public Condition<LocalDateTime> getCheckEndTimeCondition() {
		return checkEndTimeCondition;
	}

	/**
	 * 设置审核有效结束时间查询条件
	 *
	 * @param checkEndTimeCondition 审核有效结束时间查询条件
	 */
	public void setCheckEndTimeCondition(Condition<LocalDateTime> checkEndTimeCondition) {
		this.checkEndTimeCondition = checkEndTimeCondition;
	}

	/**
	 * 构造并返回已使用数量查询条件
	 *
	 * @return useNumCondition 已使用数量查询条件
	 */
	public Condition<Integer> useNum() {
		this.useNumCondition = new Condition<>();
		return this.useNumCondition;
	}

	/**
	 * 获取已使用数量查询条件
	 *
	 * @return useNumCondition 已使用数量查询条件
	 */
	public Condition<Integer> getUseNumCondition() {
		return useNumCondition;
	}

	/**
	 * 设置已使用数量查询条件
	 *
	 * @param useNumCondition 已使用数量查询条件
	 */
	public void setUseNumCondition(Condition<Integer> useNumCondition) {
		this.useNumCondition = useNumCondition;
	}

	/**
	 * 构造并返回作废数量查询条件
	 *
	 * @return invalidNumCondition 作废数量查询条件
	 */
	public Condition<Integer> invalidNum() {
		this.invalidNumCondition = new Condition<>();
		return this.invalidNumCondition;
	}

	/**
	 * 获取作废数量查询条件
	 *
	 * @return invalidNumCondition 作废数量查询条件
	 */
	public Condition<Integer> getInvalidNumCondition() {
		return invalidNumCondition;
	}

	/**
	 * 设置作废数量查询条件
	 *
	 * @param invalidNumCondition 作废数量查询条件
	 */
	public void setInvalidNumCondition(Condition<Integer> invalidNumCondition) {
		this.invalidNumCondition = invalidNumCondition;
	}

	/**
	 * 构造并返回skuId查询条件
	 *
	 * @return skuIdCondition skuId查询条件
	 */
	public Condition<String> skuId() {
		this.skuIdCondition = new Condition<>();
		return this.skuIdCondition;
	}

	/**
	 * 获取skuId查询条件
	 *
	 * @return skuIdCondition skuId查询条件
	 */
	public Condition<String> getSkuIdCondition() {
		return skuIdCondition;
	}

	/**
	 * 设置skuId查询条件
	 *
	 * @param skuIdCondition skuId查询条件
	 */
	public void setSkuIdCondition(Condition<String> skuIdCondition) {
		this.skuIdCondition = skuIdCondition;
	}

	/**
	 * 构造并返回审核金额查询条件
	 *
	 * @return checkPriceCondition 审核金额查询条件
	 */
	public Condition<BigDecimal> checkPrice() {
		this.checkPriceCondition = new Condition<>();
		return this.checkPriceCondition;
	}

	/**
	 * 获取审核金额查询条件
	 *
	 * @return checkPriceCondition 审核金额查询条件
	 */
	public Condition<BigDecimal> getCheckPriceCondition() {
		return checkPriceCondition;
	}

	/**
	 * 设置审核金额查询条件
	 *
	 * @param checkPriceCondition 审核金额查询条件
	 */
	public void setCheckPriceCondition(Condition<BigDecimal> checkPriceCondition) {
		this.checkPriceCondition = checkPriceCondition;
	}

	/**
	 * 构造并返回支付现金查询条件
	 *
	 * @return payCashCondition 支付现金查询条件
	 */
	public Condition<BigDecimal> payCash() {
		this.payCashCondition = new Condition<>();
		return this.payCashCondition;
	}

	/**
	 * 获取支付现金查询条件
	 *
	 * @return payCashCondition 支付现金查询条件
	 */
	public Condition<BigDecimal> getPayCashCondition() {
		return payCashCondition;
	}

	/**
	 * 设置支付现金查询条件
	 *
	 * @param payCashCondition 支付现金查询条件
	 */
	public void setPayCashCondition(Condition<BigDecimal> payCashCondition) {
		this.payCashCondition = payCashCondition;
	}

	/**
	 * 构造并返回备注信息查询条件
	 *
	 * @return remarksCondition 备注信息查询条件
	 */
	public Condition<String> remarks() {
		this.remarksCondition = new Condition<>();
		return this.remarksCondition;
	}

	/**
	 * 获取备注信息查询条件
	 *
	 * @return remarksCondition 备注信息查询条件
	 */
	public Condition<String> getRemarksCondition() {
		return remarksCondition;
	}

	/**
	 * 设置备注信息查询条件
	 *
	 * @param remarksCondition 备注信息查询条件
	 */
	public void setRemarksCondition(Condition<String> remarksCondition) {
		this.remarksCondition = remarksCondition;
	}

}
